home *** CD-ROM | disk | FTP | other *** search
/ TeX 1995 July / TeX CD-ROM July 1995 (Disc 1)(Walnut Creek)(1995).ISO / dviware / dvitovdu32 / src / pascal / dvireader.p < prev    next >
Text File  |  1991-11-10  |  54KB  |  1,505 lines
  1. (* Routines and data structures for use in a TeX82 DVI translator.
  2.    Much of the code in DVIReader is based on DVITYPE 2.7 by Donald Knuth.
  3.    DVITYPE is a program for verifying a DVI file and also serves as a model
  4.    for other DVI-reading programs.  See the TeXWARE manual by Knuth for a
  5.    complete description of DVITYPE and the format of DVI files.
  6.    For efficiency reasons we assume the given DVI file is formatted correctly;
  7.    it is the job of DVITYPE to diagnose bad DVI files.
  8. *)
  9.  
  10. #include 'globals.h';
  11. #include 'files.h';
  12. #include 'dvireader.h';
  13. #include 'screenio.h';
  14. #include 'fontreader.h';   (* only PixelTableRoutine *)
  15. #include 'options.h';      (* hoffset and voffset *)
  16.  
  17. (*******************************************************************************
  18.    DECLARATIONS FOR ACCESSING BYTES IN A DVI FILE
  19.  
  20.    A DVI file is a stream of 8-bit bytes.  Once opened, we can access any byte
  21.    by setting DVIoffset to the required position and then calling GetDVIByte.
  22. *)
  23.  
  24. VAR
  25.    DVIfile : integer;                 (* DVI file descriptor                  *)
  26.    DVIoffset : INTEGER;               (* current byte offset in DVIfile       *)
  27.    currDVIbuff : INTEGER;             (* starting byte offset in buffer       *)
  28.    DVIbuffer : buffer;                (* input buffer                         *)
  29.    postpostid : INTEGER;              (* offset of postpost's id byte         *)
  30.  
  31. (*******************************************************************************
  32.    DECLARATIONS FOR GETTING TO A DVI PAGE
  33.  
  34.    The user can select a particular page by specifying a DVI page
  35.    number (from 1 to totalpages), or a TeX page number (based on the
  36.    values of \count0,\count1,...,\count9), or simply requesting the next page
  37.    in the DVI file (which depends on whether we are ascending or not).
  38.    We will often need to follow the DVI backpointers to locate the bop byte
  39.    of a selected page.
  40. *)
  41.  
  42. VAR
  43.    curreop,                     (* position of eop byte of current page   *)
  44.    currbop,                     (* position of bop byte of current page   *)
  45.    lastbop : INTEGER;           (* position of last bop byte              *)
  46.    prevbop : INTEGER;           (* position of bop byte of previous page;
  47.                                    note that prevbop of first page = -1   *)
  48.  
  49. (*******************************************************************************
  50.    DECLARATIONS FOR INTERPRETING A DVI PAGE
  51.  
  52.    The commands between the bop and eop bytes for a particular page need to be
  53.    translated (based on the method used by DVITYPE) before we can determine the
  54.    the position and shape of all rules on that page, as well as the position
  55.    of all characters and which fonts they belong to.
  56. *)
  57.  
  58. CONST
  59.    (* Use symbolic names for the opcodes of DVI commands:                     *)
  60.    setchar0 = 0;         (* setchar1..setchar127 = 1..127                     *)
  61.    set1     = 128;       (* set2,set3,set4 = 129,130,131                      *)
  62.    setrule  = 132;
  63.    put1     = 133;       (* put2,put3,put4 = 134,135,136                      *)
  64.    putrule  = 137;
  65.    nop      = 138;
  66.    bop      = 139;
  67.    eop      = 140;
  68.    push     = 141;
  69.    pop      = 142;
  70.    right1   = 143;  w0 = 147;  x0 = 152;  down1 = 157;  y0 = 161;  z0 = 166;
  71.    right2   = 144;  w1 = 148;  x1 = 153;  down2 = 158;  y1 = 162;  z1 = 167;
  72.    right3   = 145;  w2 = 149;  x2 = 154;  down3 = 159;  y2 = 163;  z2 = 168;
  73.    right4   = 146;  w3 = 150;  x3 = 155;  down4 = 160;  y3 = 164;  z3 = 169;
  74.                     w4 = 151;  x4 = 156;                y4 = 165;  z4 = 170;
  75.    fntnum0  = 171;       (* fntnum1..fntnum63 = 172..234                      *)
  76.    fnt1     = 235;       (* fnt2,fnt3,fnt4 = 236,237,238                      *)
  77.    xxx1     = 239;       (* xxx2,xxx3,xxx4 = 240,241,242                      *)
  78.    fntdef1  = 243;       (* fntdef2,fntdef3,fntdef4 = 244,245,246             *)
  79.    pre      = 247;
  80.    post     = 248;
  81.    postpost = 249;
  82.    (* undefined commands = 250..255 *)
  83.  
  84.    maxstacksize  = 100;              (* maximum stack size for state values   *)
  85.    maxstacksizem = maxstacksize - 1;
  86.    maxdrift      = 2;                (* prevent hh & vv from drifting too far *)
  87.    maxint        = 2147483647;       (* 2^31 - 1                              *)
  88.  
  89. VAR
  90.    DVIcommand : 0..255;              (* holds next DVI command                *)
  91.    maxstack,                         (* max pushes over pops in DVI file      *)
  92.    num,                              (* DVI numerator                         *)
  93.    den : INTEGER;                    (* DVI denominator                       *)
  94.    conv : REAL;                      (* converts DVI units to pixels          *)
  95.    h, v,                             (* current pos on page in DVI units      *)
  96.    w, x,                             (* horizontal increments in DVI units    *)
  97.    y, z,                             (* vertical increments in DVI units      *)
  98.    hh, vv : INTEGER;                 (* h and v in pixels (approx)            *)
  99.    hhh, vvv : INTEGER;               (* h and v rounded to nearest pixel      *)
  100.    hstack, vstack,                   (* push down stacks for state values     *)
  101.    wstack, xstack,
  102.    ystack, zstack,
  103.    hhstack, vvstack : ARRAY [0..maxstacksizem] OF INTEGER;
  104.    stackpos : 0..maxstacksize;       (* stacks empty when stackpos = 0,
  105.                                         i.e., top of stacks = stackpos - 1    *)
  106.    fontspace  : INTEGER;             (* used in DoRight and DoDown            *)
  107.    thisrule   : ruleinfoptr;         (* temporary pointer to node in rulelist *)
  108.    thischar   : charinfoptr;         (* temporary pointer to node in charlist *)
  109.    thisspecial : specialinfoptr;     (* temporary ptr to node in speciallist  *)
  110.  
  111.  
  112. (******************************************************************************)
  113.  
  114. (* Here are the functions used to get byte/s from DVIfile.
  115.    They are essentially the same as those used in DVITYPE.
  116. *)
  117.  
  118. FUNCTION GetDVIByte : INTEGER;
  119.  
  120. (* Returns the value (unsigned) of the byte at DVIoffset and
  121.    advances DVIoffset for the next GetDVIByte.
  122. *)
  123.  
  124. VAR buffstart, result : INTEGER;
  125.  
  126. BEGIN
  127. buffstart := (DVIoffset DIV bufflen) * bufflen;   (* 0, bufflen, 2*bufflen... *)
  128. IF buffstart <> currDVIbuff THEN BEGIN
  129.    currDVIbuff := buffstart;
  130.    result := lseek(DVIfile, buffstart, 0);
  131.    { DEBUG
  132.      IF result <> buffstart THEN BEGIN
  133.         writeln('Lseek failed in GetDVIByte!'); RestoreTerminal; exit(1);
  134.      END;
  135.    GUBED }
  136.    result := read(DVIfile, DVIbuffer, bufflen);
  137.    { DEBUG
  138.      IF result = -1 THEN BEGIN
  139.         writeln('Read failed in GetDVIByte!'); RestoreTerminal; exit(1);
  140.      END;
  141.    GUBED }
  142. END;
  143. GetDVIByte := ORD(DVIbuffer[DVIoffset - buffstart]);
  144. DVIoffset := DVIoffset + 1;
  145. END; (* GetDVIByte *)
  146.  
  147. (******************************************************************************)
  148.  
  149. FUNCTION SignedDVIByte : INTEGER;      (* the next byte, signed *)
  150.  
  151. VAR b : INTEGER;
  152.  
  153. BEGIN
  154. b := GetDVIByte;
  155. IF b < 128 THEN
  156.    SignedDVIByte := b
  157. ELSE
  158.    SignedDVIByte := b - 256;
  159. END; (* SignedDVIByte *)
  160.  
  161. (******************************************************************************)
  162.  
  163. FUNCTION GetTwoDVIBytes : INTEGER;     (* the next 2 bytes, unsigned *)
  164.  
  165. VAR a, b : INTEGER;
  166.  
  167. BEGIN
  168. a := GetDVIByte;
  169. b := GetDVIByte;
  170. GetTwoDVIBytes := a * 256 + b;
  171. END; (* GetTwoDVIBytes *)
  172.  
  173. (******************************************************************************)
  174.  
  175. FUNCTION SignedDVIPair : INTEGER;      (* the next 2 bytes, signed *)
  176.  
  177. VAR a, b : INTEGER;
  178.  
  179. BEGIN
  180. a := GetDVIByte;
  181. b := GetDVIByte;
  182. IF a < 128 THEN
  183.    SignedDVIPair := a * 256 + b
  184. ELSE
  185.    SignedDVIPair := (a - 256) * 256 + b;
  186. END; (* SignedDVIPair *)
  187.  
  188. (******************************************************************************)
  189.  
  190. FUNCTION GetThreeDVIBytes : INTEGER;   (* the next 3 bytes, unsigned *)
  191.  
  192. VAR a, b, c : INTEGER;
  193.  
  194. BEGIN
  195. a := GetDVIByte;
  196. b := GetDVIByte;
  197. c := GetDVIByte;
  198. GetThreeDVIBytes := (a * 256 + b) * 256 + c;
  199. END; (* GetThreeDVIBytes *)
  200.  
  201. (******************************************************************************)
  202.  
  203. FUNCTION SignedDVITrio : INTEGER;      (* the next 3 bytes, signed *)
  204.  
  205. VAR a, b, c : INTEGER;
  206.  
  207. BEGIN
  208. a := GetDVIByte;
  209. b := GetDVIByte;
  210. c := GetDVIByte;
  211. IF a < 128 THEN
  212.    SignedDVITrio := (a * 256 + b) * 256 + c
  213. ELSE
  214.    SignedDVITrio := ((a - 256) * 256 + b) * 256 + c;
  215. END; (* SignedDVITrio *)
  216.  
  217. (******************************************************************************)
  218.  
  219. FUNCTION SignedDVIQuad : INTEGER;      (* the next 4 bytes, signed *)
  220.  
  221. TYPE int_or_bytes = RECORD
  222.                     CASE b : BOOLEAN OF
  223.                        TRUE  : (int : INTEGER);
  224.                        FALSE : (byt : PACKED ARRAY [0..3] OF CHAR);
  225.                     END;
  226.  
  227. VAR w : int_or_bytes;
  228.  
  229. BEGIN
  230. WITH w DO BEGIN
  231.    w.byt[0] := CHR(GetDVIByte);
  232.    w.byt[1] := CHR(GetDVIByte);
  233.    w.byt[2] := CHR(GetDVIByte);
  234.    w.byt[3] := CHR(GetDVIByte);
  235. END;
  236. SignedDVIQuad := w.int;
  237. END; (* SignedDVIQuad *)
  238.  
  239. (******************************************************************************)
  240.  
  241. PROCEDURE ProcessPostamble;
  242.  
  243. (* Having successfully opened the DVI file, we find the postamble
  244.    and initialize these global variables:
  245.    lastbop, num, den, DVImag, maxstack, totalpages.
  246.    The font definitions are read by ProcessFontDefs.
  247. *)
  248.  
  249. VAR postamblepos, postamble, pagehtplusdp, pagewidth : INTEGER;
  250.  
  251. BEGIN
  252. DVIoffset    := postpostid - 4;
  253. postamblepos := SignedDVIQuad;   (* get post_post's postamble ptr *)
  254. DVIoffset    := postamblepos;
  255. postamble    := GetDVIByte;
  256. lastbop      := SignedDVIQuad;
  257. num          := SignedDVIQuad;
  258. den          := SignedDVIQuad;
  259. DVImag       := SignedDVIQuad;
  260. pagehtplusdp := SignedDVIQuad;
  261. pagewidth    := SignedDVIQuad;
  262. maxstack     := SignedDVIPair;
  263. totalpages   := SignedDVIPair;
  264. IF maxstack > maxstacksize THEN BEGIN
  265.    writeln('Stack capacity exceeded!');
  266.    RestoreTerminal; exit(1);
  267.    (* now we don't need to test for stack overflow in DoPush *)
  268. END;
  269. { DEBUG
  270.    writeln('postamble opcode      = ', postamble:1);
  271.    writeln('postion of last bop   = ', lastbop:1);
  272.    writeln('num                   = ', num:1);
  273.    writeln('den                   = ', den:1);
  274.    writeln('DVI mag               = ', DVImag:1);
  275.    writeln('ht+dp of tallest page = ', pagehtplusdp:1);
  276.    writeln('width of widest page  = ', pagewidth:1);
  277.    writeln('max stack depth       = ', maxstack:1);
  278.    writeln('total # of pages      = ', totalpages:1);
  279. GUBED }
  280. END; (* ProcessPostamble *)
  281.  
  282. (******************************************************************************)
  283.  
  284. PROCEDURE ProcessFontDefs;
  285.  
  286. (* Read the fntdef commands in the postamble (fntdef commands in the DVI
  287.    pages will be skipped) and store the information in the font list.
  288.    (Note that complete fontspecs are NOT built here because DVIReader does not
  289.    want to know about the format or naming conventions of font files.)
  290.    Since ProcessPostamble ended by reading the totalpages parameter, the
  291.    next GetDVIByte should return nop or first fntdef.
  292. *)
  293.  
  294. VAR f, c, s, d, a, l : INTEGER;        (* hold fntdef parameters *)
  295.     i : INTEGER;     ch : CHAR;        (* for getting farea and fname *)
  296.     farea, fname : string;             (* a and l bytes long respectively *)
  297.  
  298. BEGIN
  299. totalfonts := 0;     (* number of nodes in font list *)
  300. fontlist   := NIL;
  301. REPEAT
  302.    DVIcommand := GetDVIByte;
  303.    IF (DVIcommand >= fntdef1) AND (DVIcommand <= fntdef1+3) THEN BEGIN
  304.       CASE DVIcommand - fntdef1 OF
  305.          0 : f := GetDVIByte;
  306.          1 : f := GetTwoDVIBytes;
  307.          2 : f := GetThreeDVIBytes;
  308.          3 : f := SignedDVIQuad
  309.       END;
  310.       c := SignedDVIQuad;   (* checksum; ignore it *)
  311.       s := SignedDVIQuad;   (* scaled size *)
  312.       d := SignedDVIQuad;   (* design size *)
  313.       a := GetDVIByte;      (* length of font area *)
  314.       l := GetDVIByte;      (* length of font name *)
  315.       farea := '';          (* initialize with blanks *)
  316.       FOR i := 0 TO a-1 DO BEGIN    (* read and store font area *)
  317.          ch := CHR(GetDVIByte);
  318.          IF i < maxfontspec THEN farea[i] := ch;
  319.       END;
  320.       fname := '';
  321.       FOR i := 0 TO l-1 DO BEGIN    (* read and store font name *)
  322.          ch := CHR(GetDVIByte);
  323.          IF i < maxfontspec THEN fname[i] := ch;
  324.       END;
  325.       NEW(currfont);
  326.       WITH currfont^ DO BEGIN
  327.          fontused    := FALSE;
  328.          fontnum     := f;
  329.          scaledsize  := s;
  330.          designsize  := d;
  331.          fontarea    := farea; fontarealen := a;
  332.          fontname    := fname; fontnamelen := l;
  333.          fontspec    := '';
  334.          fontspeclen := 0;        (* fontspec is built in FontReader *)
  335.          fontexists  := FALSE;    (* becomes TRUE if fontspec can be opened *)
  336.          totalchars  := 0;
  337.          charlist    := NIL;      (* first node allocated in DoFont *)
  338.          chartail    := NIL;      (* nodes are added to tail of char list *)
  339.          pixelptr    := NIL;      (* allocated once per font; see DoFont *)
  340.          nextfont    := fontlist;
  341.       END;
  342.       fontlist := currfont;       (* add new font to head of list *)
  343.       totalfonts := totalfonts + 1;
  344.    END
  345.    ELSE IF DVIcommand = nop THEN
  346.       (* nop commands can occur between DVI commands *)
  347.    ELSE IF DVIcommand = postpost THEN
  348.       (* we have reached end of postamble *)
  349.    ELSE BEGIN
  350.       writeln('Unexpected DVI command in postamble = ', DVIcommand:1);
  351.       RestoreTerminal; exit(1);
  352.    END;
  353. UNTIL DVIcommand = postpost;
  354. END; (* ProcessFontDefs *)
  355.  
  356. (******************************************************************************)
  357.  
  358. PROCEDURE OpenDVIFile (name : string);
  359.  
  360. (* If the given file can be opened and is a valid TeX82 DVI file then
  361.    the following global variables are initialized:
  362.  
  363.       DVImag      := magnification value stored in DVI file (TeX's \mag)
  364.       totalpages  := total number of pages in DVI file
  365.       currDVIpage := 0      (and remains so until a page is selected)
  366.       currTeXpage := ten 0s (ditto)
  367.       totalfonts  := total number of fonts in DVI file (= nodes in font list)
  368.       fontlist^.  (nodes are added to head of list)
  369.          fontused   := FALSE
  370.          fontnum    := internal DVI font number
  371.          scaledsize := scaled size of font (in DVI units)
  372.          designsize := design size of font (in DVI units)
  373.          fontarea   := a string of min(fontarealen,maxfontspec) characters
  374.          fontname   := a string of min(fontnamelen,maxfontspec) characters
  375.          fontspec   := a null string (fontspeclen := 0)
  376.          fontexists := FALSE
  377.          totalchars := 0
  378.          charlist   := NIL
  379.          chartail   := NIL
  380.          pixelptr   := NIL
  381.          nextfont   := next node in font list (if not NIL)
  382. *)
  383.  
  384. LABEL 666, 777, 888;
  385.  
  386. VAR length, i : integer;
  387.  
  388. BEGIN
  389. currDVIbuff := -1;   (* impossible value for first GetDVIByte *)
  390. length := 0;
  391. WHILE length < maxstring DO BEGIN
  392.    IF name[length] = ' ' THEN goto 888;
  393.    length := length + 1;
  394. END;
  395. 888:
  396. IF length < maxstring THEN name[length] := CHR(0);   (* terminate with NULL *)
  397. DVIfile := open(name, O_RDONLY, 0);
  398. IF length < maxstring THEN name[length] := ' ';      (* restore space *)
  399. IF DVIfile >= 0 THEN BEGIN
  400.    (* get offset of last DVI byte *)
  401.    DVIoffset := lseek(DVIfile, 0, 2);
  402.    IF DVIoffset = -1 THEN BEGIN
  403.       writeln('Failed to find end of file!'); RestoreTerminal; exit(1);
  404.    END;
  405.    IF DVIoffset = 0 THEN BEGIN
  406.       writeln('File is empty!'); RestoreTerminal; exit(1);
  407.    END;
  408.    { DEBUG
  409.      writeln('total bytes = ', DVIoffset:1);
  410.    GUBED }
  411.    DVIoffset := DVIoffset - 1;
  412.    WHILE TRUE DO BEGIN                          (* skip any NULs *)
  413.       IF GetDVIByte <> 0 THEN goto 777;
  414.       IF DVIoffset = 1 THEN goto 777;           (* start of file! *)
  415.       DVIoffset := DVIoffset - 2;               (* GetDVIByte increments *)
  416.    END;
  417.    777:
  418.    DVIoffset := DVIoffset - 1;
  419.    WHILE TRUE DO BEGIN                          (* skip 223s *)
  420.       IF GetDVIByte <> 223 THEN goto 666;
  421.       IF DVIoffset = 1 THEN goto 666;           (* start of file! *)
  422.       DVIoffset := DVIoffset - 2;               (* GetDVIByte increments *)
  423.    END;
  424.    666:
  425.    DVIoffset := DVIoffset - 1;
  426.    postpostid := DVIoffset;         (* remember offset of id byte *)
  427.    IF GetDVIByte <> 2 THEN BEGIN
  428.       writeln('Not a valid DVI file!'); RestoreTerminal; exit(1);
  429.    END
  430.    ELSE BEGIN
  431.       ProcessPostamble;             (* get DVImag, totalpages, etc *)
  432.       ProcessFontDefs;              (* build and initialize font list *)
  433.       currDVIpage := 0;             (* we haven't processed a page yet *)
  434.       FOR i := 0 TO 9 DO currTeXpage[i] := 0;
  435.    END;
  436. END
  437. ELSE BEGIN
  438.    writeln('Couldn''t open file: ', name:length);
  439.    RestoreTerminal; exit(1);
  440. END;
  441. END; (* OpenDVIFile *)
  442.  
  443. (******************************************************************************)
  444.  
  445. PROCEDURE SkipFntdef (which : INTEGER);
  446.  
  447. (* Read past a fntdef command without interpreting it. *)
  448.  
  449. VAR dummy, a, l, i : INTEGER;
  450.  
  451. BEGIN
  452. CASE which OF   (* which = DVIcommand - fntdef1 *)
  453.    0 : dummy := GetDVIByte;
  454.    1 : dummy := GetTwoDVIBytes;
  455.    2 : dummy := GetThreeDVIBytes;
  456.    3 : dummy := SignedDVIQuad
  457. END;
  458. dummy := SignedDVIQuad;
  459. dummy := SignedDVIQuad;
  460. dummy := SignedDVIQuad;
  461. a := GetDVIByte;        (* length of directory *)
  462. l := GetDVIByte;        (* length of font name *)
  463. FOR i := 1 TO l+a DO
  464.    dummy := GetDVIByte;
  465. END; (* SkipFntdef *)
  466.  
  467. (******************************************************************************)
  468.  
  469. PROCEDURE ReadFirstBop;
  470.  
  471. (* Read first bop by skipping past preamble; update currbop and currDVIpage. *)
  472.  
  473. VAR k, i, dummy : INTEGER;
  474.  
  475. BEGIN
  476. DVIoffset := 14;            (* position of preamble's k parameter *)
  477. k := GetDVIByte;            (* length of x parameter *)
  478. FOR i := 1 TO k DO
  479.    dummy := GetDVIByte;     (* skip preamble comment *)
  480. REPEAT   (* skip any nops and fntdefs *)
  481.    DVIcommand := GetDVIByte;
  482.    IF (DVIcommand = nop) OR (DVIcommand = bop) THEN
  483.       (* do nothing *)
  484.    ELSE IF (DVIcommand >= fntdef1) AND (DVIcommand <= fntdef1+3) THEN
  485.       SkipFntdef(DVIcommand - fntdef1)
  486.    ELSE BEGIN
  487.       WriteLine;
  488.       WriteString('Unexpected DVI command before first bop=');
  489.       WriteInt(DVIcommand); WriteLine;
  490.       RestoreTerminal; exit(1);
  491.    END;
  492. UNTIL DVIcommand = bop;
  493. currbop := DVIoffset - 1;   (* position in DVI file of first bop *)
  494. currDVIpage := 1;
  495. END; (* ReadFirstBop *)
  496.  
  497. (******************************************************************************)
  498.  
  499. PROCEDURE ReadNextBop;
  500.  
  501. (* We are currently positioned after an eop byte which we know is not the
  502.    last.  This routine positions us after the next bop byte and updates
  503.    currbop and currDVIpage.
  504. *)
  505.  
  506. BEGIN
  507. REPEAT   (* skip any nops and fntdefs *)
  508.    DVIcommand := GetDVIByte;
  509.    IF (DVIcommand = nop) OR (DVIcommand = bop) THEN
  510.       (* do nothing *)
  511.    ELSE IF (DVIcommand >= fntdef1) AND (DVIcommand <= fntdef1+3) THEN
  512.       SkipFntdef(DVIcommand - fntdef1)
  513.    ELSE BEGIN
  514.       WriteLine;
  515.       WriteString('Unexpected DVI command between eop and bop=');
  516.       WriteInt(DVIcommand); WriteLine;
  517.       RestoreTerminal; exit(1);
  518.    END;
  519. UNTIL DVIcommand = bop;
  520. currbop := DVIoffset - 1;   (* position in DVI file of this bop *)
  521. currDVIpage := currDVIpage + 1;
  522. END; (* ReadNextBop *)
  523.  
  524. (******************************************************************************)
  525.  
  526. PROCEDURE ReadBopParameters;
  527.  
  528. (* We should now be positioned after the bop of desired page, so read
  529.    the 10 TeX counters and update currTeXpage and prevbop.
  530.    At the end of this routine we will be at the byte after currbop's parameters
  531.    and ready to InterpretPage.
  532. *)
  533.  
  534. VAR i : INTEGER;
  535.  
  536. BEGIN
  537. FOR i := 0 TO 9 DO
  538.    currTeXpage[i] := SignedDVIQuad;
  539. prevbop := SignedDVIQuad;   (* position of previous bop in DVI file *)
  540. END; (* ReadBopParameters *)
  541.  
  542. (******************************************************************************)
  543.  
  544. PROCEDURE MoveToNextPage (ascending : BOOLEAN);
  545.  
  546. (* MoveToNextPage will select the next page, depending on the current page
  547.    and the specified direction.  If the value of currDVIpage is 0 (set in
  548.    OpenDVIFile), then MoveToNextPage will select the first page if ascending is
  549.    TRUE and the last page if ascending is FALSE.  If currDVIpage is > 0 then
  550.    MoveToNextPage will select currDVIpage+1 if ascending (unless currDVIpage =
  551.    totalpages, in which case it does nothing), or currDVIpage-1 if descending
  552.    (unless currDVIpage = 0).
  553.  
  554.    Before calling InterpretPage, DVItoVDU must position DVIReader to the
  555.    desired page by calling one of the MoveTo... routines.
  556.    The global variables updated if a page is located by any MoveTo... call are:
  557.       currDVIpage := the current DVI page (1..totalpages)
  558.       currTeXpage := the ten TeX counter values stored with this page
  559.    Note that currDVIpage is initially 0 until one of these routines succeeds.
  560. *)
  561.  
  562. LABEL 999;
  563.  
  564. BEGIN
  565. IF (currDVIpage = 1) AND (NOT ascending) THEN
  566.    goto 999
  567. ELSE IF (currDVIpage = totalpages) AND ascending THEN
  568.    goto 999
  569. ELSE IF currDVIpage = 0 THEN
  570.    (* we haven't processed a page yet *)
  571.    IF ascending THEN         (* get first page *)
  572.       ReadFirstBop
  573.    ELSE BEGIN                (* get last page *)
  574.       currbop := lastbop;
  575.       DVIoffset := currbop + 1;
  576.       currDVIpage := totalpages;
  577.    END
  578. ELSE
  579.    IF ascending THEN
  580.       (* currently positioned after eop of currDVIpage, so get next bop *)
  581.       ReadNextBop
  582.    ELSE BEGIN
  583.       (* move to bop pointed to by currbop's backpointer *)
  584.       currbop := prevbop;
  585.       DVIoffset := currbop + 1;   (* move to byte after previous bop *)
  586.       currDVIpage := currDVIpage - 1;
  587.    END;
  588. ReadBopParameters;   (* update currTeXpage and prevbop *)
  589. 999:
  590. END; (* MoveToNextPage *)
  591.  
  592. (******************************************************************************)
  593.  
  594. PROCEDURE MoveToDVIPage (n : INTEGER);
  595.  
  596. (* Move to nth DVI page; n should be in 1..totalpages. *)
  597.  
  598. LABEL 888, 999;
  599.  
  600. BEGIN
  601. IF (n < 1) OR (n > totalpages) THEN   (* do nothing *)
  602.    goto 999
  603. ELSE IF n = 1 THEN
  604.    (* Note that this test must come before next test so that we avoid any
  605.       problems when currDVIpage initially = 0. *)
  606.    ReadFirstBop
  607. ELSE IF n = currDVIpage + 1 THEN
  608.    ReadNextBop
  609. ELSE BEGIN
  610.    IF n < currDVIpage THEN BEGIN
  611.       currbop := prevbop;   (* start searching backwards from previous page *)
  612.       currDVIpage := currDVIpage - 1;
  613.    END
  614.    ELSE IF n > currDVIpage THEN BEGIN
  615.       currbop := lastbop;   (* start searching backwards from last page *)
  616.       currDVIpage := totalpages;
  617.    END;
  618.    (* if n = currDVIpage we'll just move back to currbop *)
  619.    (* n is now <= currDVIpage so search by following backpointers *)
  620.    WHILE TRUE DO
  621.       IF n = currDVIpage THEN BEGIN
  622.          DVIoffset := currbop + 1;      (* move to byte after currbop *)
  623.          goto 888;
  624.       END
  625.       ELSE BEGIN
  626.          DVIoffset := currbop + 41;     (* move to location of backpointer *)
  627.          currbop := SignedDVIQuad;      (* get location of previous page *)
  628.          currDVIpage := currDVIpage - 1;
  629.       END;
  630.    888:
  631. END;
  632. ReadBopParameters;   (* update currTeXpage and prevbop *)
  633. 999:
  634. END; (* MoveToDVIPage *)
  635.  
  636. (******************************************************************************)
  637.  
  638. FUNCTION CurrMatchesNew (VAR newTeXpage : TeXpageinfo) : BOOLEAN;
  639.  
  640. (* Return TRUE iff currTeXpage matches newTeXpage. *)
  641.  
  642. VAR i : 0..9;
  643.  
  644. BEGIN
  645. CurrMatchesNew := TRUE;
  646. WITH newTeXpage DO
  647.    FOR i := 0 TO lastvalue DO
  648.       IF present[i] THEN
  649.          IF value[i] <> currTeXpage[i] THEN
  650.             CurrMatchesNew := FALSE;
  651. END; (* CurrMatchesNew *)
  652.  
  653. (******************************************************************************)
  654.  
  655. FUNCTION MoveToTeXPage (VAR newTeXpage : TeXpageinfo) : BOOLEAN;
  656.  
  657. (* MoveToTeXPage will search for the lowest DVI page matching the given TeX page
  658.    specification.  (TeX stores the values of \count0,\count1,...,\count9 with
  659.    every DVI page.  Plain TeX uses \count0 to control page numbering.)
  660.    newTeXpage is a VAR parameter only for efficiency; it won't be changed.
  661.    The value array stores the requested counter values, the present array
  662.    indicates which counters are relevant and lastvalue indicates
  663.    the position (0..9) of the last relevant counter.
  664.  
  665.    DVItoVDU converts a more friendly representation
  666.    of a TeX page request into the TeXpageinfo format.  For example,
  667.    [2..5] would be converted to:     and [] would be converted to:
  668.    value     = [2,?,5,?,?,?,?,?,?,?]     value     = [?,?,?,?,?,?,?,?,?,?]
  669.    present   = [T,F,T,?,?,?,?,?,?,?]     present   = [F,?,?,?,?,?,?,?,?,?]
  670.    lastvalue =      2                    lastvalue =  0
  671.    MoveToTeXPage returns TRUE iff the requested TeX page is located.
  672. *)
  673.  
  674. LABEL 999;
  675.  
  676. VAR savecurrbop, savecurrDVIpage : INTEGER;
  677.     nextbop : INTEGER;
  678.     i : INTEGER;
  679.     atleastone : BOOLEAN;
  680.  
  681. BEGIN
  682. (* save away current page and DVI position *)
  683. savecurrDVIpage := currDVIpage;
  684. IF currDVIpage <> 0 THEN           (* only if we've processed a page *)
  685.    savecurrbop := currbop;
  686.    (* note that curreop is saved in last InterpretPage *)
  687. (* search backwards through all DVI pages for lowest matching page *)
  688. atleastone := FALSE;
  689. nextbop := lastbop;
  690. FOR i := totalpages DOWNTO 1 DO BEGIN
  691.    DVIoffset := nextbop + 1;
  692.    ReadBopParameters;              (* update currTeXpage and prevbop *)
  693.    IF CurrMatchesNew(newTeXpage) THEN BEGIN
  694.       currbop := nextbop;
  695.       currDVIpage := i;
  696.       atleastone := TRUE;
  697.    END;
  698.    nextbop := prevbop;
  699. END;
  700. IF NOT atleastone THEN BEGIN       (* no match, so restore currDVIpage *)
  701.    currDVIpage := savecurrDVIpage;
  702.    IF currDVIpage <> 0 THEN BEGIN  (* restore page and positioning info *)
  703.       currbop := savecurrbop;
  704.       DVIoffset := currbop + 1;
  705.       ReadBopParameters;           (* restore currTeXpage and prevbop *)
  706.       DVIoffset := curreop + 1;
  707.       (* we should now be after the eop byte of the original page *)
  708.    END;
  709.    MoveToTeXPage := FALSE;
  710.    goto 999;
  711. END
  712. ELSE                               (* we found lowest matching page *)
  713.    DVIoffset := currbop + 1;
  714. ReadBopParameters;                 (* update currTeXpage and prevbop *)
  715. MoveToTeXPage := TRUE;
  716. 999:
  717. END; (* MoveToTeXPage *)
  718.  
  719. (******************************************************************************)
  720.  
  721. PROCEDURE SetConversionFactor (resolution, magnification : INTEGER);
  722.  
  723. (* This routine must be called before the first InterpretPage call.
  724.    DVIReader needs to know the resolution and magnification values
  725.    before it attempts to convert DVI units into pixel values.
  726. *)
  727.  
  728. BEGIN
  729. conv := num/254000.0 * resolution/den * magnification/1000.0;
  730. END; (* SetConversionFactor *)
  731.  
  732. (******************************************************************************)
  733.  
  734. PROCEDURE InitStateValues;
  735.  
  736. (* Initialize state values and stack. *)
  737.  
  738. BEGIN
  739. hh := hoffset;         (* 0 if no horizontal shift specified *)
  740. vv := voffset;         (* 0 if no vertical shift specified *)
  741. IF hoffset >= 0 THEN
  742.    h :=   TRUNC(hoffset / conv + 0.5)
  743. ELSE
  744.    h := - TRUNC(ABS(hoffset) / conv + 0.5);
  745. IF voffset >= 0 THEN
  746.    v :=   TRUNC(voffset / conv + 0.5)
  747. ELSE
  748.    v := - TRUNC(ABS(voffset) / conv + 0.5);
  749. w := 0; x := 0;
  750. y := 0; z := 0;
  751. stackpos  := 0;
  752. fontspace := 0;        (* for DoRight and DoDown before a DoFont call *)
  753. END; (* InitStateValues *)
  754.  
  755. (******************************************************************************)
  756.  
  757. PROCEDURE InitPage;
  758.  
  759. (* Initialize page so that there are no fonts, chars, rules, specials. *)
  760.  
  761. BEGIN
  762. (* page edges will change if there is at least one char or rule on page *)
  763. minhp := maxint;
  764. minvp := maxint;
  765. maxhp := -maxint;
  766. maxvp := -maxint;
  767. currfont := fontlist;
  768. WHILE currfont <> NIL DO
  769.    WITH currfont^ DO BEGIN
  770.       IF fontused THEN BEGIN  (* only reset those fonts used in last page *)
  771.          fontused := FALSE;
  772.          totalchars := 0;
  773.          (* deallocate char list completely; DoFont will allocate first node *)
  774.          WHILE charlist <> NIL DO BEGIN
  775.             thischar := charlist;
  776.             charlist := thischar^.nextchar;
  777.             DISPOSE(thischar);
  778.          END;
  779.          chartail := NIL;
  780.          (* pixel table remains allocated *)
  781.       END;
  782.       currfont := nextfont;
  783.    END;
  784. currfont   := NIL;            (* current font is undefined at start of page *)
  785. totalrules := 0;
  786. (* deallocate rule information except for one node (for DoSet/PutRule) *)
  787. WHILE rulelist <> ruletail DO BEGIN
  788.    thisrule := rulelist;
  789.    rulelist := thisrule^.nextrule;
  790.    DISPOSE(thisrule);
  791. END;
  792. rulelist^.rulecount := 0;     (* no rules in this node *)
  793. rulelist^.nextrule  := NIL;
  794. (* deallocate \special information *)
  795. WHILE speciallist <> NIL DO BEGIN
  796.    thisspecial := speciallist;
  797.    speciallist := speciallist^.nextspecial;
  798.    DISPOSE(thisspecial);
  799. END;
  800. END; (* InitPage *)
  801.  
  802. (******************************************************************************)
  803.  
  804. FUNCTION PixelRound (DVIunits : INTEGER) : INTEGER;
  805.  
  806. (* Return the nearest number of pixels in the given DVI dimension. *)
  807.  
  808. BEGIN
  809. IF DVIunits > 0 THEN
  810.    PixelRound :=   TRUNC(conv * DVIunits + 0.5)
  811. ELSE
  812.    PixelRound := - TRUNC(conv * ABS(DVIunits) + 0.5);
  813. END; (* PixelRound *)
  814.  
  815. (******************************************************************************)
  816.  
  817. PROCEDURE DoSetChar (ch : INTEGER);
  818.  
  819. (* Add char info to current chartable, update our horizontal
  820.    position on the page and check the page edges.
  821. *)
  822.  
  823. LABEL 999;
  824.  
  825. BEGIN
  826. WITH currfont^ DO BEGIN
  827.    IF ch > maxTeXchar THEN BEGIN
  828.       WriteString('Unknown character from'); WriteChar(' ');
  829.       WriteString(fontspec);
  830.       goto 999;                           (* ignore ch *)
  831.    END;
  832.    WITH chartail^ DO
  833.       IF charcount = chartablesize THEN BEGIN
  834.          (* allocate a new chartable *)
  835.          NEW(nextchar);                   (* add new node to end of char list *)
  836.          nextchar^.charcount := 0;        (* reset charcount *)
  837.          nextchar^.nextchar  := NIL;
  838.          chartail := nextchar;
  839.       END;
  840.    WITH chartail^ DO BEGIN                (* may be new chartable *)
  841.       WITH chartable[charcount] DO BEGIN
  842.          hp := hh;
  843.          vp := vv;
  844.          code := ch;
  845.       END;
  846.       WITH pixelptr^[ch] DO BEGIN
  847.          (* do page edges increase? *)
  848.          IF vv - yo < minvp THEN minvp := vv - yo;
  849.          IF hh - xo < minhp THEN minhp := hh - xo;
  850.          IF vv + (ht - yo - 1) > maxvp THEN maxvp := vv + (ht - yo - 1);
  851.          IF hh + (wd - xo - 1) > maxhp THEN maxhp := hh + (wd - xo - 1);
  852.          (* the above checks ensure that page edges include all black
  853.             pixels in glyph, but we also want to include reference point *)
  854.          IF hh < minhp THEN minhp := hh;
  855.          IF vv < minvp THEN minvp := vv;
  856.          IF hh > maxhp THEN maxhp := hh;
  857.          IF vv > maxvp THEN maxvp := vv;
  858.          (* add pixel width calculated in PixelTableRoutine *)
  859.          hh := hh + pwidth;
  860.          (* use hhh and maxdrift to prevent hh drifting too far from h *)
  861.          hhh := PixelRound(h + dwidth);
  862.          IF ABS(hhh - hh) > maxdrift THEN
  863.             IF hhh > hh THEN
  864.                hh := hhh - maxdrift
  865.             ELSE
  866.                hh := hhh + maxdrift;
  867.          (* add DVI width calculated in PixelTableRoutine *)
  868.          h := h + dwidth;
  869.       END;
  870.       totalchars := totalchars + 1;
  871.       charcount := charcount + 1;
  872.    END;
  873. END;
  874. 999:
  875. END; (* DoSetChar *)
  876.  
  877. (******************************************************************************)
  878.  
  879. PROCEDURE DoPutChar (ch : INTEGER);
  880.  
  881. (* Exactly the same as DoSetChar, but we DON'T update the horizontal
  882.    position on the page.  (We still have to check page edges.)
  883. *)
  884.  
  885. LABEL 999;
  886.  
  887. BEGIN
  888. WITH currfont^ DO BEGIN
  889.    IF ch > maxTeXchar THEN BEGIN
  890.       WriteString('Unknown character from'); WriteChar(' ');
  891.       WriteString(fontspec);
  892.       goto 999;                           (* ignore ch *)
  893.    END;
  894.    WITH chartail^ DO
  895.       IF charcount = chartablesize THEN BEGIN
  896.          (* allocate a new chartable *)
  897.          NEW(nextchar);                   (* add new node to end of char list *)
  898.          nextchar^.charcount := 0;        (* reset charcount *)
  899.          nextchar^.nextchar  := NIL;
  900.          chartail := nextchar;
  901.       END;
  902.    WITH chartail^ DO BEGIN                (* may be new chartable *)
  903.       WITH chartable[charcount] DO BEGIN
  904.          hp := hh;
  905.          vp := vv;
  906.          code := ch;
  907.       END;
  908.       WITH pixelptr^[ch] DO BEGIN
  909.          (* do page edges increase? *)
  910.          IF vv - yo < minvp THEN minvp := vv - yo;
  911.          IF hh - xo < minhp THEN minhp := hh - xo;
  912.          IF vv + (ht - yo - 1) > maxvp THEN maxvp := vv + (ht - yo - 1);
  913.          IF hh + (wd - xo - 1) > maxhp THEN maxhp := hh + (wd - xo - 1);
  914.          (* the above checks ensure that page edges include all black
  915.             pixels in glyph, but we also want to include reference point *)
  916.          IF hh < minhp THEN minhp := hh;
  917.          IF vv < minvp THEN minvp := vv;
  918.          IF hh > maxhp THEN maxhp := hh;
  919.          IF vv > maxvp THEN maxvp := vv;
  920.       END;
  921.       totalchars := totalchars + 1;
  922.       charcount := charcount + 1;
  923.    END;
  924. END;
  925. 999:
  926. END; (* DoPutChar *)
  927.  
  928. (******************************************************************************)
  929.  
  930. PROCEDURE DoPush;
  931.  
  932. (* Push state values onto stack.
  933.    No need to test for stack overflow since we compare maxstack and
  934.    maxstacksize in ProcessPostamble.
  935. *)
  936.  
  937. BEGIN
  938. hstack[stackpos] := h;   vstack[stackpos] := v;
  939. wstack[stackpos] := w;   xstack[stackpos] := x;
  940. ystack[stackpos] := y;   zstack[stackpos] := z;
  941. hhstack[stackpos] := hh; vvstack[stackpos] := vv;
  942. stackpos := stackpos + 1;
  943. END; (* DoPush *)
  944.  
  945. (******************************************************************************)
  946.  
  947. PROCEDURE DoPop;
  948.  
  949. (* Pop state values from top of stack. *)
  950.  
  951. BEGIN
  952. { DEBUG
  953.   IF stackpos = 0 THEN BEGIN
  954.      WriteLine; WriteString('Stack empty!'); WriteLine;
  955.      RestoreTerminal; exit(1);
  956.   END;
  957. GUBED }
  958. stackpos := stackpos - 1;
  959. h := hstack[stackpos];   v := vstack[stackpos];
  960. w := wstack[stackpos];   x := xstack[stackpos];
  961. y := ystack[stackpos];   z := zstack[stackpos];
  962. hh := hhstack[stackpos]; vv := vvstack[stackpos];
  963. END; (* DoPop *)
  964.  
  965. (******************************************************************************)
  966.  
  967. PROCEDURE DoRight (amount : INTEGER);
  968.  
  969. (* Move the reference point horizontally by given amount (usually +ve).
  970.    When the amount is small, like a kern, hh changes
  971.    by rounding the amount; but when the amount is large, hh changes by rounding
  972.    the true position h so that accumulated rounding errors disappear.
  973. *)
  974.  
  975. BEGIN
  976. IF (amount < fontspace) AND (amount > -4 * fontspace) THEN BEGIN
  977.    hh  := hh + PixelRound(amount);
  978.    (* use hhh and maxdrift to prevent hh drifting too far from h *)
  979.    hhh := PixelRound(h + amount);
  980.    IF ABS(hhh - hh) > maxdrift THEN
  981.       IF hhh > hh THEN
  982.          hh := hhh - maxdrift
  983.       ELSE
  984.          hh := hhh + maxdrift;
  985. END
  986. ELSE
  987.    hh := PixelRound(h + amount);
  988. h := h + amount;
  989. END; (* DoRight *)
  990.  
  991. (******************************************************************************)
  992.  
  993. PROCEDURE DoDown (amount : INTEGER);
  994.  
  995. (* Move the reference point vertically by given amount (usually +ve).
  996.    Rounding is done similarly to DoRight but with the threshold between
  997.    small and large amounts increased by a factor of 5.
  998. *)
  999.  
  1000. BEGIN
  1001. IF ABS(amount) < 5 * fontspace THEN BEGIN
  1002.    vv := vv + PixelRound(amount);
  1003.    (* use vvv and maxdrift to prevent vv drifting too far from v *)
  1004.    vvv := PixelRound(v + amount);
  1005.    IF ABS(vvv - vv) > maxdrift THEN
  1006.       IF vvv > vv THEN
  1007.          vv := vvv - maxdrift
  1008.       ELSE
  1009.          vv := vvv + maxdrift;
  1010. END
  1011. ELSE
  1012.    vv := PixelRound(v + amount);
  1013. v := v + amount;
  1014. END; (* DoDown *)
  1015.  
  1016. (******************************************************************************)
  1017.  
  1018. FUNCTION RulePixels (DVIunits : INTEGER) : INTEGER;
  1019.  
  1020. (* Return the number of pixels in the given height or width of a rule
  1021.    using the method recommended in DVITYPE.
  1022. *)
  1023.  
  1024. VAR n : INTEGER;
  1025.  
  1026. BEGIN
  1027. n := TRUNC(conv * DVIunits);
  1028. IF n < conv * DVIunits THEN RulePixels := n + 1 ELSE RulePixels := n;
  1029. END; (* RulePixels *)
  1030.  
  1031. (******************************************************************************)
  1032.  
  1033. PROCEDURE DoSetRule (height, width : INTEGER);
  1034.  
  1035. (* Add rule information to current ruletable, update page edges, h and hh
  1036.    (but only if width and height are > 0).
  1037. *)
  1038.  
  1039. BEGIN
  1040. IF (height > 0) AND (width > 0) THEN BEGIN
  1041.    WITH ruletail^ DO
  1042.       IF rulecount = ruletablesize THEN BEGIN
  1043.          (* allocate a new ruletable *)
  1044.          NEW(nextrule);                   (* add new node to end of rule list *)
  1045.          nextrule^.rulecount := 0;        (* reset rulecount *)
  1046.          nextrule^.nextrule  := NIL;
  1047.          ruletail := nextrule;
  1048.       END;
  1049.    WITH ruletail^ DO BEGIN                (* may be new ruletable *)
  1050.       WITH ruletable[rulecount] DO BEGIN
  1051.          hp := hh;
  1052.          vp := vv;
  1053.          wd := RulePixels(width);
  1054.          ht := RulePixels(height);
  1055.          (* do page edges increase? *)
  1056.          IF vv - (ht - 1) < minvp THEN minvp := vv - (ht - 1);
  1057.          IF hh + (wd - 1) > maxhp THEN maxhp := hh + (wd - 1);
  1058.          (* ref pt of rule is bottom left black pixel *)
  1059.          IF vv > maxvp THEN maxvp := vv;
  1060.          IF hh < minhp THEN minhp := hh;
  1061.          hh := hh + wd;
  1062.          (* use hhh and maxdrift to prevent hh drifting too far from h *)
  1063.          hhh := PixelRound(h + width);
  1064.          IF ABS(hhh - hh) > maxdrift THEN
  1065.             IF hhh > hh THEN
  1066.                hh := hhh - maxdrift
  1067.             ELSE
  1068.                hh := hhh + maxdrift;
  1069.          h := h + width;
  1070.       END;
  1071.       totalrules := totalrules + 1;
  1072.       rulecount := rulecount + 1;
  1073.    END;
  1074. END;
  1075. END; (* DoSetRule *)
  1076.  
  1077. (******************************************************************************)
  1078.  
  1079. PROCEDURE DoPutRule (height, width : INTEGER);
  1080.  
  1081. (* Exactly the same as DoSetRule, but we DON'T update the horizontal
  1082.    position on the page.  (We still have to check page edges.)
  1083. *)
  1084.  
  1085. BEGIN
  1086. IF (height > 0) AND (width > 0) THEN BEGIN
  1087.    WITH ruletail^ DO
  1088.       IF rulecount = ruletablesize THEN BEGIN
  1089.          (* allocate a new ruletable *)
  1090.          NEW(nextrule);                   (* add new node to end of rule list *)
  1091.          nextrule^.rulecount := 0;        (* reset rulecount *)
  1092.          nextrule^.nextrule := NIL;
  1093.          ruletail := nextrule;
  1094.       END;
  1095.    WITH ruletail^ DO BEGIN                (* may be new ruletable *)
  1096.       WITH ruletable[rulecount] DO BEGIN
  1097.          hp := hh;
  1098.          vp := vv;
  1099.          wd := RulePixels(width);
  1100.          ht := RulePixels(height);
  1101.          (* do page edges increase? *)
  1102.          IF vv - (ht - 1) < minvp THEN minvp := vv - (ht - 1);
  1103.          IF hh + (wd - 1) > maxhp THEN maxhp := hh + (wd - 1);
  1104.          (* ref pt of rule is bottom left black pixel *)
  1105.          IF vv > maxvp THEN maxvp := vv;
  1106.          IF hh < minhp THEN minhp := hh;
  1107.       END;
  1108.       totalrules := totalrules + 1;
  1109.       rulecount := rulecount + 1;
  1110.    END;
  1111. END;
  1112. END; (* DoPutRule *)
  1113.  
  1114. (******************************************************************************)
  1115.  
  1116. PROCEDURE DoFont (externf : INTEGER);
  1117.  
  1118. (* Search font list for externf, setting currfont and fontspace.
  1119.    If this is the first time we've seen this font (on current page) then
  1120.    we need to allocate the first chartable.
  1121.    If this is the first time we've seen this font used at all then we
  1122.    allocate a pixeltable and call routine to fill it in.
  1123. *)
  1124.  
  1125. LABEL 888;
  1126.  
  1127. BEGIN
  1128. currfont := fontlist;
  1129. WHILE currfont <> NIL DO
  1130.    IF currfont^.fontnum <> externf THEN
  1131.       currfont := currfont^.nextfont
  1132.    ELSE
  1133.       goto 888;
  1134. 888:
  1135. { DEBUG
  1136.   IF currfont = NIL THEN BEGIN
  1137.      WriteLine; WriteString('Failed to find font #'); WriteInt(externf);
  1138.      WriteLine; RestoreTerminal; exit(1);
  1139.   END;
  1140. GUBED }
  1141. WITH currfont^ DO BEGIN
  1142.    IF fontused THEN
  1143.       (* do nothing since we've already used this font on this page *)
  1144.    ELSE BEGIN
  1145.       fontused := TRUE;
  1146.       NEW(charlist);           (* allocate first chartable *)
  1147.       WITH charlist^ DO BEGIN
  1148.          charcount := 0;       (* for DoSet/PutChar *)
  1149.          nextchar  := NIL;     (* this node is also last *)
  1150.       END;
  1151.       chartail := charlist;
  1152.       IF pixelptr = NIL THEN BEGIN  (* first time we've seen this font *)
  1153.          NEW(pixelptr);
  1154.          PixelTableRoutine;
  1155.       END;
  1156.    END;
  1157.    fontspace  := scaledsize DIV 6;
  1158.    (* See DVITYPE; a 3-unit thin space.
  1159.       Note that a thin space is 1/6 of a quad, where a quad is
  1160.       1 em in the current font and usually equals the design size.
  1161.    *)
  1162. END;
  1163. END; (* DoFont *)
  1164.  
  1165. (******************************************************************************)
  1166.  
  1167. PROCEDURE DoSpecial (hpos, vpos, totalbytes : INTEGER);   (* in *)
  1168.  
  1169. (* DVIReader has seen a \special command while interpreting the current page.
  1170.    It will pass the current page position and number of bytes in the command.
  1171.    We save the info away in speciallist for later use by the main program.
  1172. *)
  1173.  
  1174. VAR i, flush : INTEGER;     temp : specialinfoptr;
  1175.  
  1176. BEGIN
  1177. NEW(temp);
  1178. WITH temp^ DO BEGIN
  1179.    special := '';                     (* SYSDEP: fill with spaces *)
  1180.    FOR i := 0 TO totalbytes-1 DO
  1181.       IF i < maxspeciallen THEN special[i] := CHR(GetDVIByte);
  1182.    (* we must read all the \special bytes *)
  1183.    IF totalbytes > maxspeciallen THEN BEGIN
  1184.       FOR i := 1 TO totalbytes - maxspeciallen DO flush := GetDVIByte;
  1185.    END;
  1186.    hp := hpos;
  1187.    vp := vpos;
  1188.    nextspecial := speciallist;
  1189. END;
  1190. speciallist := temp;                  (* add new info to head of list *)
  1191. END; (* DoSpecial *)
  1192.  
  1193. (******************************************************************************)
  1194.  
  1195. PROCEDURE InterpretPage;
  1196.  
  1197. (* When this routine is called we are positioned after the bytes of a bop
  1198.    command (i.e., at currbop + 45).  At the end of this routine we will be
  1199.    positioned after the eop byte for the current page.  In between we carry
  1200.    out the important task of translating the DVI description of this page
  1201.    and filling in the following global data structures:
  1202.  
  1203.       totalrules := number of rules on page
  1204.       rulelist^. (nodes are added to tail of rule list)
  1205.          rulecount  := number of rules in this ruletable
  1206.          ruletable[0..rulecount-1].
  1207.             hp, vp  := reference point of a rule
  1208.             wd, ht  := pixel dimensions of a rule (both > 0)
  1209.          nextrule   := next node in rule list (if not NIL)
  1210.       ruletail   := pointer to last node in rule list
  1211.  
  1212.       speciallist^. (nodes are added to head of this list)
  1213.          hp, vp      := reference point on page
  1214.          special     := \special bytes
  1215.          nextspecial := next node in list (if not NIL)
  1216.  
  1217.       fontlist^.
  1218.          (the following fontinfo is relevant only if fontused is TRUE)
  1219.          totalchars := number of chars on page from this font
  1220.          charlist^. (nodes are added to tail of char list)
  1221.             charcount  := number of chars in this chartable
  1222.             chartable[0..charcount-1].
  1223.                hp, vp  := reference point of a character
  1224.                code    := TeX character code (and index into pixel table)
  1225.             nextchar   := next node in char list (if not NIL)
  1226.          chartail   := pointer to last node in char list
  1227.          pixelptr^[0..maxTeXchar].
  1228.             (filled in by FontReader's PixelTableRoutine)
  1229.             wd, ht  := glyph width and height in pixels
  1230.             xo, yo  := offsets from the character's reference point
  1231.             dwidth  := advance width in DVI units
  1232.             pwidth  := advance width in pixels
  1233.             mapadr  := offset in fontspec of the glyph's bitmap info
  1234.             bitmap  := NIL
  1235.          nextfont   := next node in font list (if not NIL)
  1236.  
  1237.       pageempty  := TRUE iff the page has no rules and no characters
  1238.       minhp, minvp, maxhp, maxvp
  1239.                  := the edges of the page (undefined if pageempty is TRUE)
  1240.                     They define the smallest rectangle containing all black
  1241.                     pixels on the page;(minhp,minvp) is the top left corner.
  1242.  
  1243.    Reference points for rules and characters are stored as a pair of
  1244.    horizontal and vertical pixel coordinates.  The point (0,0) is assumed
  1245.    to be the pixel 1 inch in from the top and left edges of an imaginary sheet
  1246.    of paper.  Horizontal coordinates increase to the right and vertical
  1247.    coordinates increase down the paper.
  1248.    The number of pixels per inch is defined by the resolution parameter
  1249.    given to SetConversionFactor.
  1250. *)
  1251.  
  1252. VAR param, ht, wd : INTEGER;
  1253.  
  1254. BEGIN
  1255. InitStateValues;
  1256. InitPage;
  1257. REPEAT
  1258.    DVIcommand := GetDVIByte;
  1259.    (* For efficiency reasons the most frequent commands should be tested 1st.
  1260.       The following order is the result of frequency testing on typical
  1261.       DVI files.  Note that the most frequent commands in the DVI file
  1262.       generated by TeX 1.3 for the Dec. 1983 LaTeX manual were:
  1263.       <set1, w0, right3, push/pop, x0, w3, y0, fntnum25, right2, fntnum31,
  1264.       down3, x2, right4, w2, x3, down4, z0, fntnum8, setrule, y3, etc.
  1265.    *)
  1266.    IF DVIcommand < set1       THEN DoSetChar(DVIcommand)   (* 0..127 *)
  1267.    ELSE IF DVIcommand = w0      THEN DoRight(w)
  1268.    ELSE IF DVIcommand = right3  THEN DoRight(SignedDVITrio)
  1269.    ELSE IF DVIcommand = push    THEN DoPush
  1270.    ELSE IF DVIcommand = pop     THEN DoPop
  1271.    ELSE IF DVIcommand = x0      THEN DoRight(x)
  1272.    ELSE IF DVIcommand = w3      THEN BEGIN w := SignedDVITrio; DoRight(w) END
  1273.    ELSE IF DVIcommand = y0      THEN DoDown(y)
  1274.  
  1275.    ELSE IF (DVIcommand > z4) AND (DVIcommand < fnt1)   (* fntnum0..fntnum63 *)
  1276.                               THEN DoFont(DVIcommand - fntnum0)
  1277.  
  1278.    (* catch all the remaining movement commands *)
  1279.    ELSE IF (DVIcommand > pop) AND (DVIcommand < fntnum0) THEN BEGIN
  1280.       IF DVIcommand = right2     THEN DoRight(SignedDVIPair)
  1281.       ELSE IF DVIcommand = right4  THEN DoRight(SignedDVIQuad)
  1282.       ELSE IF DVIcommand = x2      THEN BEGIN x := SignedDVIPair; DoRight(x) END
  1283.       ELSE IF DVIcommand = x3      THEN BEGIN x := SignedDVITrio; DoRight(x) END
  1284.       ELSE IF DVIcommand = down3   THEN DoDown(SignedDVITrio)
  1285.       ELSE IF DVIcommand = down4   THEN DoDown(SignedDVIQuad)
  1286.       ELSE IF DVIcommand = w2      THEN BEGIN w := SignedDVIPair; DoRight(w) END
  1287.       ELSE IF DVIcommand = z0      THEN DoDown(z)
  1288.       ELSE IF DVIcommand = y3      THEN BEGIN y := SignedDVITrio; DoDown(y) END
  1289.       ELSE IF DVIcommand = z3      THEN BEGIN z := SignedDVITrio; DoDown(z) END
  1290.       ELSE IF DVIcommand = down2   THEN DoDown(SignedDVIPair)
  1291.       (* the next DVI commands are used very rarely (by TeX 1.3 at least) *)
  1292.       ELSE IF DVIcommand = w1      THEN BEGIN w := SignedDVIByte; DoRight(w) END
  1293.       ELSE IF DVIcommand = w4      THEN BEGIN w := SignedDVIQuad; DoRight(w) END
  1294.       ELSE IF DVIcommand = x1      THEN BEGIN x := SignedDVIByte; DoRight(x) END
  1295.       ELSE IF DVIcommand = x4      THEN BEGIN x := SignedDVIQuad; DoRight(x) END
  1296.       ELSE IF DVIcommand = y1      THEN BEGIN y := SignedDVIByte; DoDown(y) END
  1297.       ELSE IF DVIcommand = y2      THEN BEGIN y := SignedDVIPair; DoDown(y) END
  1298.       ELSE IF DVIcommand = y4      THEN BEGIN y := SignedDVIQuad; DoDown(y) END
  1299.       ELSE IF DVIcommand = z1      THEN BEGIN z := SignedDVIByte; DoDown(z) END
  1300.       ELSE IF DVIcommand = z2      THEN BEGIN z := SignedDVIPair; DoDown(z) END
  1301.       ELSE IF DVIcommand = z4      THEN BEGIN z := SignedDVIQuad; DoDown(z) END
  1302.       ELSE IF DVIcommand = right1  THEN DoRight(SignedDVIByte)
  1303.       ELSE IF DVIcommand = down1   THEN DoDown(SignedDVIByte)
  1304.       ELSE BEGIN
  1305.            WriteLine; WriteString('Bug in InterpretPage!'); WriteLine;
  1306.            RestoreTerminal; exit(1);
  1307.       END;
  1308.    END
  1309.    ELSE IF DVIcommand = setrule THEN BEGIN
  1310.            ht := SignedDVIQuad; wd := SignedDVIQuad; DoSetRule(ht,wd);
  1311.    END
  1312.    ELSE IF DVIcommand = putrule THEN BEGIN
  1313.            ht := SignedDVIQuad; wd := SignedDVIQuad; DoPutRule(ht,wd);
  1314.    END
  1315.    ELSE IF (DVIcommand >= put1) AND (DVIcommand <= put1+3) THEN
  1316.       CASE DVIcommand - put1 OF
  1317.          0 : DoPutChar(GetDVIByte);
  1318.          1 : DoPutChar(GetTwoDVIBytes);
  1319.          2 : DoPutChar(GetThreeDVIBytes);
  1320.          3 : DoPutChar(SignedDVIQuad)
  1321.       END
  1322.  
  1323.    ELSE IF (DVIcommand >= set1) AND (DVIcommand <= set1+3) THEN
  1324.       CASE DVIcommand - set1 OF
  1325.          0 : DoSetChar(GetDVIByte);
  1326.          1 : DoSetChar(GetTwoDVIBytes);
  1327.          2 : DoSetChar(GetThreeDVIBytes);
  1328.          3 : DoSetChar(SignedDVIQuad)
  1329.       END
  1330.  
  1331.    ELSE IF (DVIcommand >= fnt1) AND (DVIcommand <= fnt1+3) THEN
  1332.       CASE DVIcommand - fnt1 OF
  1333.          0 : DoFont(GetDVIByte);
  1334.          1 : DoFont(GetTwoDVIBytes);
  1335.          2 : DoFont(GetThreeDVIBytes);
  1336.          3 : DoFont(SignedDVIQuad)
  1337.       END
  1338.  
  1339.    ELSE IF (DVIcommand >= xxx1) AND (DVIcommand <= xxx1+3) THEN BEGIN
  1340.       CASE DVIcommand - xxx1 OF
  1341.          0 : param := GetDVIByte;
  1342.          1 : param := GetTwoDVIBytes;
  1343.          2 : param := GetThreeDVIBytes;
  1344.          3 : param := SignedDVIQuad
  1345.       END;
  1346.       (* pass current pixel position and number of bytes *)
  1347.       DoSpecial(hh, vv, param);
  1348.    END
  1349.  
  1350.    (* skip fntdef command since we've got this info from postamble *)
  1351.    ELSE IF (DVIcommand >= fntdef1) AND (DVIcommand <= fntdef1+3)
  1352.                               THEN SkipFntdef(DVIcommand - fntdef1)
  1353.  
  1354.    ELSE IF DVIcommand = nop   THEN (* do nothing *)
  1355.    ELSE IF DVIcommand = eop   THEN (* do nothing *)
  1356.    ELSE BEGIN
  1357.       WriteLine;
  1358.       WriteString('Unexpected DVI command while interpreting page=');
  1359.       WriteInt(DVIcommand); WriteLine;
  1360.       RestoreTerminal; exit(1);
  1361.    END;
  1362. UNTIL DVIcommand = eop;
  1363. (* save position of eop byte for use in MoveToTeXPage *)
  1364. curreop := DVIoffset - 1;
  1365. IF stackpos <> 0 THEN BEGIN
  1366.    WriteLine;
  1367.    WriteString('Stack not empty at eop!'); WriteLine;
  1368.    RestoreTerminal; exit(1);
  1369. END;
  1370. pageempty := (minhp = maxint) AND (minvp = maxint) AND
  1371.              (maxhp = -maxint) AND (maxvp = -maxint); (* InitPage values *)
  1372. END; (* InterpretPage *)
  1373.  
  1374. (******************************************************************************)
  1375.  
  1376. PROCEDURE SortFonts (VAR unusedlist : fontinfoptr);   (* out *)
  1377.  
  1378. (* Sort fontlist in order of ascending totalchars.
  1379.    Fonts with least characters can then be accessed first.
  1380.    Since the number of fonts used on a typical page is quite small, a simple
  1381.    sorting algorithm should be good enough.  Note that unused fonts are moved
  1382.    to the end of the list and unusedlist points to the first such node.
  1383.    DVItoVDU need only process fonts up to (but excluding) unusedlist
  1384.    and does not have to worry about checking the fontused flag.
  1385.    If unusedlist is NIL then either 1) all fonts are used on the current page
  1386.    or 2) fontlist is also NIL (totalfonts = 0).
  1387. *)
  1388.  
  1389. VAR newfontlist, prevfont, largest, prevlargest : fontinfoptr;
  1390.     mostchars : INTEGER;
  1391.  
  1392. BEGIN
  1393. newfontlist  := NIL;
  1394. (* go thru fontlist once and move all unused fonts to head of newfontlist *)
  1395. prevfont := NIL;
  1396. currfont := fontlist;
  1397. WHILE currfont <> NIL DO
  1398.    WITH currfont^ DO
  1399.       IF fontused THEN BEGIN
  1400.          prevfont := currfont;      (* remember previous node *)
  1401.          currfont := nextfont;
  1402.       END
  1403.       ELSE
  1404.          (* move node from fontlist to head of newfontlist
  1405.             and don't change prevfont
  1406.          *)
  1407.          IF prevfont = NIL THEN BEGIN
  1408.             fontlist := nextfont;   (* remove first node in fontlist *)
  1409.             nextfont := newfontlist;
  1410.             newfontlist := currfont;
  1411.             currfont := fontlist;
  1412.          END
  1413.          ELSE BEGIN
  1414.             prevfont^.nextfont := nextfont;
  1415.             nextfont := newfontlist;
  1416.             newfontlist := currfont;
  1417.             currfont := prevfont^.nextfont;
  1418.          END;
  1419. (* unusedlist will be last unused font moved to newfontlist.  It will be NIL
  1420.    if either fontlist is NIL or all fonts are used.
  1421. *)
  1422. unusedlist := newfontlist;
  1423. (* Now go thru fontlist repeatedly moving node with max totalchars to
  1424.    head of newfontlist until fontlist is exhausted.
  1425. *)
  1426. WHILE fontlist <> NIL DO BEGIN
  1427.    prevfont := NIL;
  1428.    currfont := fontlist;
  1429.    prevlargest := NIL;
  1430.    largest     := fontlist;
  1431.    mostchars   := 0;
  1432.    WHILE currfont <> NIL DO   (* search for largest totalchars *)
  1433.       WITH currfont^ DO BEGIN
  1434.          IF totalchars > mostchars THEN BEGIN
  1435.             prevlargest := prevfont;
  1436.             largest     := currfont;
  1437.             mostchars   := totalchars;
  1438.          END;
  1439.          prevfont := currfont;
  1440.          currfont := nextfont;
  1441.       END;
  1442.    (* move largest node from fontlist to head of newfontlist *)
  1443.    WITH largest^ DO BEGIN
  1444.       IF prevlargest = NIL THEN
  1445.          fontlist := nextfont   (* remove first node in fontlist *)
  1446.       ELSE
  1447.          prevlargest^.nextfont := nextfont;
  1448.       nextfont := newfontlist;
  1449.       newfontlist := largest;
  1450.    END;
  1451. END;
  1452. fontlist := newfontlist;   (* used fonts now sorted and unused fonts at end *)
  1453. END; (* SortFonts *)
  1454.  
  1455. (******************************************************************************)
  1456.  
  1457. PROCEDURE CloseDVIFile;
  1458.  
  1459. (* Close the currently open DVI file and deallocate dynamic data structures. *)
  1460.  
  1461. VAR result : integer;
  1462.  
  1463. BEGIN
  1464. result := close(DVIfile);
  1465. WHILE fontlist <> NIL DO BEGIN
  1466.    currfont := fontlist;
  1467.    WITH currfont^ DO BEGIN
  1468.       WHILE charlist <> NIL DO BEGIN
  1469.          thischar := charlist;
  1470.          charlist := thischar^.nextchar;
  1471.          DISPOSE(thischar);      (* deallocate char list *)
  1472.       END;
  1473.       IF pixelptr <> NIL THEN
  1474.          DISPOSE(pixelptr);      (* deallocate pixel table *)
  1475.       fontlist := nextfont;
  1476.    END;
  1477.    DISPOSE(currfont);            (* deallocate font information *)
  1478. END;
  1479. (* Deallocate rule information except for one node (in case DVItoVDU ever
  1480.    opens another DVI file).
  1481. *)
  1482. WHILE rulelist <> ruletail DO BEGIN
  1483.    thisrule := rulelist;
  1484.    rulelist := thisrule^.nextrule;
  1485.    DISPOSE(thisrule);
  1486. END;
  1487. WHILE speciallist <> NIL DO BEGIN
  1488.    thisspecial := speciallist;
  1489.    speciallist := speciallist^.nextspecial;
  1490.    DISPOSE(thisspecial);
  1491. END;
  1492. END; (* CloseDVIFile *)
  1493.  
  1494. (******************************************************************************)
  1495.  
  1496. PROCEDURE InitDVIReader;
  1497.  
  1498. BEGIN
  1499. totalrules := 0;
  1500. NEW(rulelist);             (* for first InitPage *)
  1501. ruletail := rulelist;      (* ditto *)
  1502. speciallist := NIL;        (* ditto *)
  1503. fontlist := NIL;           (* safer for CloseDVIFile *)
  1504. END; (* InitDVIReader *)
  1505.